package com.cy.aircompressor.main.ui.onlinemonitor.utils;

import android.content.Context;
import android.graphics.Color;
import android.view.MotionEvent;

import androidx.annotation.ColorRes;

import com.blankj.utilcode.util.TimeUtils;
import com.cy.aircompressor.R;
import com.cy.aircompressor.entity.linechart.LineChartEntry;
import com.drug.lib.util.DLog;
import com.github.mikephil.charting.animation.Easing;
import com.github.mikephil.charting.charts.LineChart;
import com.github.mikephil.charting.components.AxisBase;
import com.github.mikephil.charting.components.Description;
import com.github.mikephil.charting.components.Legend;
import com.github.mikephil.charting.components.LegendEntry;
import com.github.mikephil.charting.components.LimitLine;
import com.github.mikephil.charting.components.MarkerImage;
import com.github.mikephil.charting.components.XAxis;
import com.github.mikephil.charting.components.YAxis;
import com.github.mikephil.charting.data.Entry;
import com.github.mikephil.charting.data.LineData;
import com.github.mikephil.charting.data.LineDataSet;
import com.github.mikephil.charting.formatter.IAxisValueFormatter;
import com.github.mikephil.charting.formatter.IValueFormatter;
import com.github.mikephil.charting.highlight.Highlight;
import com.github.mikephil.charting.interfaces.datasets.ILineDataSet;
import com.github.mikephil.charting.listener.ChartTouchListener;
import com.github.mikephil.charting.listener.OnChartGestureListener;
import com.github.mikephil.charting.listener.OnChartValueSelectedListener;
import com.github.mikephil.charting.utils.ViewPortHandler;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class LineChartUtil {
    public static final String defaultLineColor = "#3C6579";


    /**
     * 添加一条默认曲线
     *
     * @param mLineChart
     */
    public static void addEmptyLine(LineChart mLineChart) {
        LineData lineData = mLineChart.getData();
        if (lineData != null) {
            removeAllLine(mLineChart);
        }
        lineData = initLineData();
        LineDataSet dataSet = getLineDataSet(getEmptyEntrys(), defaultLineColor);
        lineData.addDataSet(dataSet);
        // set data
        mLineChart.setData(lineData);
        setXAxis(mLineChart, null, false);
        mLineChart.invalidate();
    }

    /**
     * 检查是否添加曲线到LineChart
     *
     * @param mLineChart
     */
    public static void checkLineChart(LineChart mLineChart) {
        LineData lineData = mLineChart.getData();
        if (lineData == null) {
            addEmptyLine(mLineChart);
        }
    }

    /**
     * 添加单条曲线
     */
    public static void addAndUpdateLine(LineChart mLineChart, LineChartEntry lineChartEntry) {
        addAndUpdateLine(mLineChart, lineChartEntry, false);
    }

    public static void addAndUpdateLine(LineChart mLineChart, LineChartEntry lineChartEntry, boolean isZoom) {
        if (lineChartEntry == null || lineChartEntry.getEntrys() == null
                || (lineChartEntry.getEntrys() != null && lineChartEntry.getEntrys().size() == 0)) {
            return;
        }
        LineData lineData = mLineChart.getData();
        if (lineData == null) {
            lineData = initLineData();
        }
        List<ILineDataSet> list = lineData.getDataSets();
        if (list.size() > 0) {
            int position = lineChartEntry.getPosition();
            if (position < 0) {
                addNewLine(mLineChart, lineChartEntry, isZoom);
            } else if (list.size() >= position) {
                updateLine(mLineChart, lineChartEntry);
            }
        } else {
            addNewLine(mLineChart, lineChartEntry, isZoom);
        }
    }

    /**
     * 同时添加多曲线
     *
     * @param mLineChart
     * @param lineChartEntry
     */
    public static void addAndUpdateLine(LineChart mLineChart, List<LineChartEntry> lineChartEntry) {
        addAndUpdateLine(mLineChart, lineChartEntry, false);
    }

    public static void addAndUpdateLine(LineChart mLineChart, List<LineChartEntry> lineChartEntry, boolean isZoom) {
        List<ILineDataSet> lineDataSets = new ArrayList<>();
        lineChartEntry.forEach(new Consumer<LineChartEntry>() {
            @Override
            public void accept(LineChartEntry lineChartEntry) {
                lineDataSets.add(getLineDataSet(lineChartEntry.getEntrys(), lineChartEntry.getColor()));
            }
        });
        if (lineDataSets == null || lineDataSets.size() == 0) {
            return;
        }
        removeAllLine(mLineChart);
        LineData data = initLineData(lineDataSets);
        // set data
        setXAxis(mLineChart, filtrateMaxEntrys(lineChartEntry), isZoom);
        mLineChart.setData(data);
        data.notifyDataChanged();
        mLineChart.notifyDataSetChanged();
        mLineChart.invalidate();
    }

    private static List<Entry> filtrateMaxEntrys(List<LineChartEntry> lineChartEntrys) {
        LineChartEntry lineChartEntry = lineChartEntrys.stream().max(new Comparator<LineChartEntry>() {
            @Override
            public int compare(LineChartEntry o1, LineChartEntry o2) {
                if (o1.getEntrys() == null && o2.getEntrys() == null) return 0;
                if (o1.getEntrys() != null && o2.getEntrys() == null) return o1.getEntrys().size();
                if (o1.getEntrys() == null && o2.getEntrys() != null) return o2.getEntrys().size();
                return o1.getEntrys().size() >= o2.getEntrys().size() ? o1.getEntrys().size() : o2.getEntrys().size();
            }
        }).get();
        if (lineChartEntry != null) return lineChartEntry.getEntrys();
        return null;
    }

    /**
     * 加入一条新的曲线
     *
     * @param mLineChart
     * @param lineChartEntry
     */
    private static void addNewLine(LineChart mLineChart, LineChartEntry lineChartEntry, boolean isZoom) {
        LineData lineData = mLineChart.getData();
        if (lineData == null) return;
        LineDataSet dataSet = getLineDataSet(lineChartEntry.getEntrys(), lineChartEntry.getColor());
        lineData.addDataSet(dataSet);
        mLineChart.notifyDataSetChanged();
        lineData.notifyDataChanged();
        lineChartEntry.setPosition(lineData.getIndexOfDataSet(dataSet));
        setXAxis(mLineChart, lineChartEntry.getEntrys(), isZoom);
        mLineChart.invalidate();
    }

    /**
     * 更新曲线数据
     *
     * @param mLineChart
     * @param lineChartEntry
     */
    private static void updateLine(LineChart mLineChart, LineChartEntry lineChartEntry) {
        LineData lineData = mLineChart.getData();
        if (lineData == null) return;
        List<ILineDataSet> list = lineData.getDataSets();
        if (list.size() <= lineChartEntry.getPosition()) {
            return;
        }
        LineDataSet newDataSet = getLineDataSet(lineChartEntry.getEntrys(), lineChartEntry.getColor());
        lineData.getDataSets().set(lineChartEntry.getPosition(), newDataSet);
        lineData.notifyDataChanged();
        mLineChart.notifyDataSetChanged();
        mLineChart.invalidate();
    }

    /**
     * 清空LineChart所有数据
     *
     * @param mLineChart
     */
    public static void removeAllLine(LineChart mLineChart) {
        if (mLineChart.getData() != null) {
            mLineChart.clearValues();
            mLineChart.clear();
        }
    }


    private static List<Entry> getEmptyEntrys() {
        List<Entry> entries = new ArrayList<>();
        long currentTime = System.currentTimeMillis() - 60 * 60 * 1000;
        for (int i = 0; i < 10; i++) {
            Entry entry = new Entry(i, 0f, currentTime);
            entries.add(entry);
            currentTime = currentTime + 6 * 60 * 1000;
        }
        return entries;
    }

    /**
     * 获得一条线的配置（*）
     *
     * @param values
     * @param color
     * @return
     */
    private static LineDataSet getLineDataSet(List<Entry> values, String color) {
        // create a dataset and give it a type
        LineDataSet dataSet = new LineDataSet(values, "");
        dataSet.setMode(LineDataSet.Mode.CUBIC_BEZIER);//用于设置线条的类型，Mode枚举值，如Mode.CUBIC_BEZIER表示贝塞尔曲线
        dataSet.setCubicIntensity(1.0f);//设置线条Mode类型的强度，0-1

        //线条下方设置填充
        dataSet.setDrawFilled(false);//是否在线条下方设置填充，bool类型
        dataSet.setFillColor(Color.WHITE);//设置在曲线下方填充的颜色
        dataSet.setFillAlpha(100);
        //圆点设置
        dataSet.setDrawCircles(false);//是否绘制圆点，若为false则表示只有折线
        dataSet.setCircleRadius(4f);//设置圆点的半径大小
        dataSet.setCircleColor(Color.parseColor("#FF03DAC5"));//一次性设置所有圆点的颜色
        //空心圆设置
        dataSet.setDrawCircleHole(false);//设置是否为空心圆
        dataSet.setCircleColorHole(Color.WHITE);
        dataSet.setCircleHoleRadius(2f);

        // Y轴更多属性
        dataSet.setAxisDependency(YAxis.AxisDependency.LEFT);  // 设置dataSet应绘制在Y轴的左轴还是右轴，默认LEFT
        //X Y高亮指示器
        dataSet.setHighlightEnabled(false);  // 能否高亮,默认true
        dataSet.setDrawHighlightIndicators(true);   // 画高亮指示器,默认true
        dataSet.setDrawHorizontalHighlightIndicator(true);  // 画水平高亮指示器，默认true
        dataSet.setDrawVerticalHighlightIndicator(true);    // 垂直方向高亮指示器,默认true
        dataSet.setHighLightColor(Color.parseColor("#1FC6FF")); // 高亮颜色,默认RGB(255, 187, 115)
        dataSet.setHighlightLineWidth(1.0f);

        dataSet.setDrawValues(false);// 绘制每个点的值
        //设置折线
        dataSet.setLineWidth(1.5f);//设置折线的宽度
        dataSet.setColor(Color.parseColor(color));//设置折线的颜色,有三个构造方法

        dataSet.setValueFormatter(new IValueFormatter() {
            @Override
            public String getFormattedValue(float value, Entry entry, int dataSetIndex, ViewPortHandler viewPortHandler) {
                return value + "";
            }   // 将值转换为想要显示的形式，比如，某点值为1，变为“1￥”,MP提供了三个默认的转换器，
            // LargeValueFormatter:将大数字变为带单位数字；PercentFormatter：将值转换为百分数；StackedValueFormatter，对于BarChart，是否只显示最大值图还是都显示
        });
        return dataSet;
    }

    private static LineData initLineData(List<ILineDataSet> lineDataSets) {
        // *********************LineData***************************** //
        LineData lineData;
        if (lineDataSets != null) {
            lineData = new LineData(lineDataSets);
        } else {
            lineData = new LineData();
        }
        lineData.setValueTextColor(Color.WHITE);   // 该条线的
        lineData.setValueTextSize(12);   // 文字大小
        lineData.setValueTypeface(null); // 文字字体
        lineData.setValueFormatter(new IValueFormatter() {  // 所有数据显示的数据值
            @Override
            public String getFormattedValue(float value, Entry entry, int dataSetIndex, ViewPortHandler viewPortHandler) {
                return String.format("%.1f", value);
            }
        });
        lineData.setDrawValues(false);   // 绘制每个点的值
        return lineData;
    }

    private static LineData initLineData() {
        return initLineData(null);
    }

    public static void setLimit(LineChart mLineChart, float limit) {
        YAxis yAxis = mLineChart.getAxisLeft();
        // 限制线
        LimitLine ll = new LimitLine(limit, "上限"); // 创建限制线, 这个线还有一些相关的绘制属性方法，自行看一下就行，没多少东西。
        ll.setTextColor(Color.RED);
        yAxis.addLimitLine(ll); // 添加限制线到轴上
//        yAxis.removeLimitLine(ll);  // 移除指定的限制线,还有其他的几个移除方法
        yAxis.setDrawLimitLinesBehindData(false); // 限制线在数据之后绘制。默认为false
        mLineChart.invalidate();
    }

    public static void setXAxis(LineChart mLineChart, List<Entry> entries, boolean isZoom) {
        XAxis xAxis = mLineChart.getXAxis();
//        int count = entries.size() > 100 ? 10 : 8;
        xAxis.setLabelCount(10, false); // 纵轴上标签显示的数量,数字不固定。如果force = true,将会画出明确数量，但是可能值导致不均匀，默认（6，false）
        IAxisValueFormatter iAxisValueFormatter = new IAxisValueFormatter() {

            @Override
            public String getFormattedValue(float value, AxisBase axis) {
                if (entries == null) return String.valueOf(value);
                int position = entries.size();
                if (position <= (int) value) return String.valueOf(value);
                Object data = entries.get((int) value).getData();
                if (data == null) {
                    return String.valueOf(value);
                } else {
                    long date = (long) entries.get((int) value).getData();
                    try {
                        return StringToDate(date);
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                    return String.valueOf(value);
                }
//                return String.format("%.1f", value);
            }

            @Override
            public int getDecimalDigits() {
                return 0;
            }
        };
        xAxis.setValueFormatter(iAxisValueFormatter);
        if (isZoom) {
            //设置一页最大显示个数为6，超出部分就滑动
            float ratio = getRatio(entries.size());
            //显示的时候是按照多大的比率缩放显示,1f表示不放大缩小
            mLineChart.zoom(ratio, 1f, 0, 0);
            //设置从X轴出来的动画时间
            //mLineChart.animateX(1500);
            //设置XY轴动画
//        mLineChart.animateXY(1500, 1500, Easing.EasingOption.EaseInSine, Easing.EasingOption.EaseInSine);
        }
//        YAxis yAxis = mLineChart.getAxisLeft();
//        yAxis.setAxisMaximum(500);
        //设置Marker
//        mLineChart.setMarker(new XYMarkerView(mLineChart.getContext(), iAxisValueFormatter));
    }

    private static float getRatio(int size) {
        if (size < 100) {
            return 1.0f;
        } else if (size > 100 && size < 1000) {
            return (float) size / (float) 500;
        } else if (size > 1000 && size < 5000) {
            return (float) size / (float) 1000;
        }
        return 1.0f;
    }

    private static String StringToDate(long time) throws ParseException {

//        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        SimpleDateFormat format1 = new SimpleDateFormat("MM-dd HH:mm");
        SimpleDateFormat format1 = new SimpleDateFormat("HH:mm");
        String s = format1.format(time);
        return s;

    }

    public static void setHighlightValue(LineChart mLineChart, float x, int dataSetIndex) {
        mLineChart.highlightValue(x, dataSetIndex);    // 高亮指定值，可以指定数据集的值,还有其他几个重载方法
        mLineChart.invalidate();
    }

    public static void initLineChart(LineChart mLineChart, boolean enabled) {
        // **************************图表本身一般样式**************************** //
        setLineChart(mLineChart, enabled);

        // ***********************X Y **轴****************************** //
        setXYAxis(mLineChart);

        // *********************图例***************************** //
        setLegend(mLineChart, false);

    }


    private static void setLineChart(LineChart mLineChart, boolean enabled) {
        // **************************图表本身一般样式**************************** //
        mLineChart.setBackgroundColor(Color.TRANSPARENT); // 整个图标的背景色
//        mLineChart.setContentDescription(iki  "温度变化趋势");   // 右下角的描述文本,测试并不显示

        Description description = new Description();  // 这部分是深度定制描述文本，颜色，字体等
        description.setText("温度变化趋势");
        description.setTextColor(Color.WHITE);
        description.setEnabled(false);
        mLineChart.setDescription(description);

        mLineChart.setViewPortOffsets(40, 0, 20, 40);
        mLineChart.setNoDataText("暂无数据");   // 没有数据时样式
        mLineChart.setDrawGridBackground(false);    // 绘制区域的背景（默认是一个灰色矩形背景）将绘制，默认false
        mLineChart.setGridBackgroundColor(Color.parseColor("#02EA93"));  // 绘制区域的背景色

        mLineChart.setDrawBorders(false);    // 绘制区域边框绘制，默认false
        mLineChart.setBorderColor(Color.GREEN); // 边框颜色
        mLineChart.setBorderWidth(1);   // 边框宽度,dp
        mLineChart.setMaxVisibleValueCount(100);  // 数据点上显示的标签，最大数量，默认100。且dataSet.setDrawValues(true);必须为true。只有当数据数量小于该值才会绘制标签


        // *********************滑动相关*************************** //
        mLineChart.setTouchEnabled(enabled); // 所有触摸事件,默认true
        mLineChart.setDragEnabled(enabled);    // 可拖动,默认true
        mLineChart.setScaleEnabled(enabled);   // 两个轴上的缩放,X,Y分别默认为true
        mLineChart.setScaleXEnabled(enabled);  // X轴上的缩放,默认true
        mLineChart.setScaleYEnabled(enabled);  // Y轴上的缩放,默认true
        mLineChart.setPinchZoom(enabled);  // X,Y轴同时缩放，false则X,Y轴单独缩放,默认false
        mLineChart.setDoubleTapToZoomEnabled(enabled); // 双击缩放,默认true
        mLineChart.setDragDecelerationEnabled(enabled);    // 抬起手指，继续滑动,默认true
        mLineChart.setDragDecelerationFrictionCoef(0.9f);   // 摩擦系数,[0-1]，较大值速度会缓慢下降，0，立即停止;1,无效值，并转换为0.9999.默认0.9f.
        mLineChart.setOnChartGestureListener(new OnChartGestureListener() { // 手势监听器
            @Override
            public void onChartGestureStart(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) {
                // 按下
            }

            @Override
            public void onChartGestureEnd(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) {
                // 抬起,取消
            }

            @Override
            public void onChartLongPressed(MotionEvent me) {
                // 长按
            }

            @Override
            public void onChartDoubleTapped(MotionEvent me) {
                // 双击
            }

            @Override
            public void onChartSingleTapped(MotionEvent me) {
                // 单击
            }

            @Override
            public void onChartFling(MotionEvent me1, MotionEvent me2, float velocityX, float velocityY) {
                // 甩动
            }

            @Override
            public void onChartScale(MotionEvent me, float scaleX, float scaleY) {
                // 缩放
            }

            @Override
            public void onChartTranslate(MotionEvent me, float dX, float dY) {
                // 移动
            }
        });


        // ************************高亮*************************** //
        mLineChart.setHighlightPerDragEnabled(enabled);    // 拖拽时能否高亮（十字瞄准触摸到的点），默认true
        mLineChart.setHighlightPerTapEnabled(enabled); // 双击时能都高亮，默认true
        mLineChart.setMaxHighlightDistance(500);    // 最大高亮距离（dp）,点击位置距离数据点的距离超过这个距离不会高亮，默认500dp

        mLineChart.setOnChartValueSelectedListener(new OnChartValueSelectedListener() { // 值选择监听器
            @Override
            public void onValueSelected(Entry e, Highlight h) {
                // 选中
            }

            @Override
            public void onNothingSelected() {
                // 未选中
            }
        });
        mLineChart.invalidate();    // 重绘
        // ********************其他******************************* //
        mLineChart.setLogEnabled(false);    // 是否打印日志，默认false
//        mLineChart.notifyDataSetChanged();  // 通知有值变化，重绘，一般动态添加数据时用到

        // ******************指定缩放显示范围************************* //
        // 这里要说一下，下面并不是指定其初始显示的范围，所以，很可能大家觉得没有效果。其实这几个方法目的是限制缩放时的可见范围最值。
//        mLineChart.setVisibleXRangeMaximum(6); // X轴缩小可见最大范围，这里测试有点问题，范围不是指定的，可以缩小到更多范围。
//        mLineChart.setVisibleXRangeMinimum(4);  // X轴放大最低可见范围，最小意思是，再怎么放大范围也至少要有4，但是一开始显示的时候范围可能很大。
//        mLineChart.setVisibleYRangeMaximum(4, YAxis.AxisDependency.LEFT);   // Y缩小时可见最大范围，后面是其适用的轴。测试发现两边轴都是有效的
//        mLineChart.setVisibleYRangeMinimum(2, YAxis.AxisDependency.LEFT);   // Y轴放大时可见最小范围。
//        mLineChart.setVisibleYRange(3, 5, YAxis.AxisDependency.LEFT);   // y轴缩放时可见最小和最大范围。但是测试发现不能放大3的范围，但是也是符合这个限制的
//        mLineChart.setVisibleXRange(3, 6);  // X轴缩放时可见最小和最大范围。测试也有点问题
//        mLineChart.setViewPortOffsets(10, 0, 10, 0);    // 图表绘制区的偏移量设置,这个会忽略MP的自动计算偏移。
        // 比如，自动时，图例与绘制区是分开的，但是自己写就可能重和在一起。慎用
//        mLineChart.resetViewPortOffsets();  // 重置上面的偏移量设置。
//        mLineChart.setExtraOffsets(10, 0, 10, 0);   // 这个与上面的区别是不会忽略其自己计算的偏移。

        // **************************移动******************************** //
//        mLineChart.fitScreen(); // 重置所有缩放与拖动，使图标完全符合其边界
//        mLineChart.moveViewToX(30); // 想指定向偏移，比如原本显示前三个点，现在显示后三个，如果没有缩放其实看不出啥效果

//        mLineChart.moveViewTo(30, 10, YAxis.AxisDependency.LEFT);    // 向指定方向偏移,如果没有缩放其实看不出啥效果,后面的轴没啥效果
//        mLineChart.moveViewToAnimated(30, 10, YAxis.AxisDependency.LEFT, 2000); // 同上面那个，但是有动画效果
//        mLineChart.centerViewTo(30, 10, YAxis.AxisDependency.LEFT); // 将视图中心移动到指定位置，也是要缩放才有效果
//        mLineChart.centerViewToAnimated(30, 10, YAxis.AxisDependency.LEFT, 2000); // 同上面那个，但是有动画效果


        // ****************************自动缩放********************************** //
        // 这里的缩放效果会收到setVisibleXRangeMaximum等范围影响，
//        mLineChart.zoomIn();    // 自动放大1.4倍，没看出效果
//        mLineChart.zoomOut();   // 自动缩小0.7倍，没看出效果
//        mLineChart.zoom(2f, 2f, 2, 3, YAxis.AxisDependency.LEFT);
//        mLineChart.zoomAndCenterAnimated(1.4f, 1.4f, 2, 3, YAxis.AxisDependency.LEFT, 3000);    // 缩放，有动画，报了个空指针。。。


        // ************************动画************************************** //
        /*mLineChart.animateX(3000);  // 数据从左到右动画依次显示
        mLineChart.animateY(3000);  // 数据从下到上动画依次显示*/
        mLineChart.animateXY(3000, 3000);   // 上面两个的结合
//        mLineChart.animateX(3000, Easing.EasingOption.EaseInQuad); // 动画播放随时间变化的速率，有点像插值器。后面这个有的不能用


        // **************************所有数据样式************************************ //
//        mLineChart.setMarker(new XYMarkerView(mContext, R.mipmap.img_up));
//        mLineChart.setMarker(new ChartMarkerView(this, R.layout.item_chart_indicator, "温度:", "℃"));    // 点击数据点显示的pop，有俩默认的，MarkerImage：一张图片，MarkerView:一个layout布局,也可以自己定义.这里这个是我自定义的一个MarkerView。


        // **************************图表本身特殊样式******************************** //
        mLineChart.setAutoScaleMinMaxEnabled(false);    // y轴是否自动缩放；当缩放时，y轴的显示会自动根据x轴范围内数据的最大最小值而调整。财务报表比较有用，默认false
        mLineChart.setKeepPositionOnRotation(false); // 设置当屏幕方向变化时，是否保留之前的缩放与滚动位置，默认：false
    }

    // *************************轴****************************** //
    // 由四个元素组成：
    // 标签：即刻度值。也可以自定义，比如时间，距离等等，下面会说一下；
    // 轴线：坐标轴；
    // 网格线：垂直于轴线对应每个值画的轴线；
    // 限制线：最值等线。
    private static void setXYAxis(LineChart mLineChart) {
        mLineChart.getAxisRight().setEnabled(false);    // 不绘制右侧的轴线

        XAxis xAxis = mLineChart.getXAxis();    // 获取X轴
        xAxis.setEnabled(true); // 轴线是否可编辑,默认true
        xAxis.setDrawLabels(true);  // 是否绘制标签,默认true
        xAxis.setDrawAxisLine(true);    // 是否绘制坐标轴,默认true
//        xAxis.setAxisMaximum(20); // 此轴能显示的最大值；
//        xAxis.resetAxisMaximum();   // 撤销最大值；
//        xAxis.setAxisMinimum(0);    // 此轴显示的最小值；
//        xAxis.resetAxisMinimum();   // 撤销最小值；
        xAxis.setGranularity(1); // 设置X轴值之间最小距离。正常放大到一定地步，标签变为小数值，到一定地步，相邻标签都是一样的。这里是指定相邻标签间最小差，防止重复。
        // X轴绘制位置，默认是顶部
        xAxis.setPosition(XAxis.XAxisPosition.BOTTOM);

        //网格线
        xAxis.setDrawGridLines(false);// 是否绘制网格线，默认true
        xAxis.setGridColor(Color.parseColor("#A2B0B8"));    // 网格线颜色，默认GRAY
        xAxis.setGridLineWidth(0.3f);    // 网格线宽度，dp，默认1dp
        xAxis.enableGridDashedLine(2, 2, 1);    // 网格线为虚线，lineLength，每段实线长度,spaceLength,虚线间隔长度，phase，起始点（进过测试，最后这个参数也没看出来干啥的）
        // 轴字体
        xAxis.setTextColor(Color.parseColor("#A2B0B8"));  // 标签字体颜色
        xAxis.setTextSize(10f);    // 标签字体大小，dp，6-24之间，默认为10dp
        xAxis.setTypeface(null);    // 标签字体
        xAxis.setLabelRotationAngle(25);   // 标签倾斜角度
        // 轴颜色
        // 那么如果x轴有线且有网格线，当刻度拉的正好位置时会覆盖到y轴的轴线，变为X轴网格线颜色，结局办法是，要么不画轴线，要么就是坐标轴稍微宽点
        xAxis.setAxisLineColor(Color.parseColor("#A2B0B8"));  // 坐标轴颜色，默认GRAY.测试到一个bug，假如左侧线只有1dp，
        xAxis.setAxisLineWidth(1);  // 坐标轴线宽度，dp，默认1dp
        xAxis.setLabelCount(15, false); // 纵轴上标签显示的数量,数字不固定。如果force = true,将会画出明确数量，但是可能值导致不均匀，默认（6，false）

        // 轴值转换显示
        xAxis.setValueFormatter(new IAxisValueFormatter() {
            @Override
            public String getFormattedValue(float value, AxisBase axis) {
                return String.valueOf(value);
            }

            @Override
            public int getDecimalDigits() {
                return 0;
            }

        });


        YAxis yAxis = mLineChart.getAxisLeft(); // 获取Y轴,mLineChart.getAxis(YAxis.AxisDependency.LEFT);也可以获取Y轴
        yAxis.setDrawLabels(true); // 不设置坐标轴数据标签
        yAxis.setDrawAxisLine(false); // 不绘制坐标轴线
        yAxis.setDrawZeroLine(false); // 绘制零线
//        yAxis.setStartAtZero(true);  // 从0开始绘制。已弃用。使用setAxisMinimum(float)；
//        yAxis.setInverted(true); // 反转轴,默认false
        yAxis.setSpaceTop(0);   // 设置最大值到图标顶部的距离占所有数据范围的比例。默认10，y轴独有
        // 算法：比例 = （y轴最大值 - 数据最大值）/ (数据最大值 - 数据最小值) ；
        // 用途：可以通过设置该比例，使线最大最小值不会触碰到图标的边界。
        // 注意：设置一条线可能不太好看，mLineChart.getAxisRight().setSpaceTop(34)也设置比较好;同时，如果设置最小值，最大值，会影响该效果
        yAxis.setSpaceBottom(0);   // 同上，只不过是最小值距离底部比例。默认10，y轴独有
        yAxis.setLabelCount(6, false); // 纵轴上标签显示的数量,数字不固定。如果force = true,将会画出明确数量，但是可能值导致不均匀，默认（6，false）
        yAxis.setPosition(YAxis.YAxisLabelPosition.OUTSIDE_CHART);  // 标签绘制位置。默认再坐标轴外面
        yAxis.setAxisMinimum(0);    // 此轴显示的最小值；
//        yAxis.setAxisMaximum(10);   // 此轴显示的最小值；
        yAxis.setGranularity(1);    // 同上
        yAxis.setGranularityEnabled(false); // 是否禁用上面颗粒度限制。默认false

        //网格线
        yAxis.setDrawGridLines(true); // 不绘制网格线
        yAxis.setGridColor(Color.parseColor("#A2B0B8"));    // 网格线颜色，默认GRAY
        yAxis.setGridLineWidth(1f);    // 网格线宽度，dp，默认1dp
        // 轴字体
        yAxis.setTextColor(Color.parseColor("#A2B0B8"));  // 标签字体颜色
        yAxis.setTextSize(10f);    // 标签字体大小，dp，6-24之间，默认为10dp
        yAxis.setTypeface(null);    // 标签字体
        // 轴颜色
        yAxis.setAxisLineColor(Color.parseColor("#A2B0B8"));  // 坐标轴颜色，默认GRAY.测试到一个bug，假如左侧线只有1dp，
        yAxis.setAxisLineWidth(1);  // 坐标轴线宽度，dp，默认1dp
        yAxis.enableGridDashedLine(3, 4, 1);    // 网格线为虚线，lineLength，每段实线长度,spaceLength,虚线间隔长度，phase，起始点（进过测试，最后这个参数也没看出来干啥的）

        yAxis.setDrawZeroLine(false);    // 绘制值为0的轴，默认false,其实比较有用的就是在柱形图，当有负数时，显示在0轴以下，其他的图这个可能会看到一些奇葩的效果
        yAxis.setZeroLineWidth(10);  // 0轴宽度
        yAxis.setZeroLineColor(Color.BLUE);   // 0轴颜色
        yAxis.setValueFormatter(new IAxisValueFormatter() {
            @Override
            public String getFormattedValue(float value, AxisBase axis) {
                return String.format("%.1f", value);
            }

            @Override
            public int getDecimalDigits() {
                return 0;
            }

        });
    }

    private static void setLegend(LineChart mLineChart, boolean enabled) {
        // *********************图例***************************** //
        Legend legend = mLineChart.getLegend(); // 获取图例，但是在数据设置给chart之前是不可获取的
        legend.setEnabled(enabled);    // 是否绘制图例
        legend.setTextColor(Color.WHITE);    // 图例标签字体颜色，默认BLACK
        legend.setTextSize(6); // 图例标签字体大小[6,24]dp,默认10dp
        legend.setTypeface(null);   // 图例标签字体
        legend.setWordWrapEnabled(false);    // 当图例超出时是否换行适配，这个配置会降低性能，且只有图例在底部时才可以适配。默认false
        legend.setMaxSizePercent(1f); // 设置，默认0.95f,图例最大尺寸区域占图表区域之外的比例
        legend.setForm(Legend.LegendForm.CIRCLE);   // 设置图例的形状，SQUARE, CIRCLE 或者 LINE 或者隐藏NONE
        legend.setFormSize(3); // 图例图形尺寸，dp，默认8dp
        legend.setXEntrySpace(3);  // 设置水平图例间间距，默认6dp
        legend.setYEntrySpace(0);  // 设置垂直图例间间距，默认0
        legend.setFormToTextSpace(3);    // 设置图例的标签与图形之间的距离，默认5dp
        legend.setWordWrapEnabled(true);   // 图标单词是否适配。只有在底部才会有效，
        legend.setDirection(Legend.LegendDirection.LEFT_TO_RIGHT);
        legend.setVerticalAlignment(Legend.LegendVerticalAlignment.TOP);

        legend.setCustom(new LegendEntry[]{new LegendEntry("label1", Legend.LegendForm.CIRCLE, 10, 5, null, Color.RED),
                new LegendEntry("label2", Legend.LegendForm.CIRCLE, 10, 5, null, Color.GRAY),
                new LegendEntry("label3", Legend.LegendForm.CIRCLE, 10, 5, null, Color.RED)}); // 这个应该是之前的setCustom(int[] colors, String[] labels)方法
        // 这个方法会把前面设置的图例都去掉，重置为指定的图例。
//        legend.resetCustom();   // 去掉上面方法设置的图例，然后之前dataSet中设置的会重新显示。
//        legend.setExtra(new int[]{Color.RED, Color.GRAY, Color.GREEN}, new String[]{"label1", "label2", "label3"}); // 添加图例，颜色与label数量要一致。
        // 如果前面已经在dataSet中设置了颜色，那么之前的图例就存在，这个只是添加在后面的图例，并不一定有对应数据。
        mLineChart.invalidate();    // 重绘
    }
}
